home *** CD-ROM | disk | FTP | other *** search
/ Aminet 1 (Walnut Creek) / Aminet - June 1993 [Walnut Creek].iso / aminet / dev / m2 / menugadget.lha / MenuGadgetDemo.mod < prev   
Text File  |  1993-01-29  |  10KB  |  276 lines
  1. MODULE MenuGadgetDemo;
  2.  
  3.    (* MenuGadgetDemo.mod - Erzeugt mehrere MenuGadget und demonstriert deren
  4.     *                      Verwendung.
  5.     * Version  : 1.01 (29.01.93)
  6.     * Compiler : M2Amiga V4.107d
  7.     * Aurfuf   : m2c -zyne+@ MenuGadgetDemo
  8.     *            m2l -cdr MenuGadgetDemo
  9.     * Copyright: © 1993 by Fin Schuppenhauer
  10.     *
  11.     * Dieses Programm demonstriert die Verwendung der Prozeduren für
  12.     * die Erzeugung und Handhabung der MenuGadgets.
  13.     * Dieses Programm darf durchaus verändert werden, jedoch darf eine
  14.     * veränderte Version nicht durch das Orginal ausgetauscht und so
  15.     * weiter vertrieben werden.
  16.     *
  17.     * Dieses Programm ist SHAREWARE. Wenn es Dir gefällt und Du es
  18.     * häufiger benutzt (bzw. die hier zur Verfügung gestellten Prozeduren
  19.     * in eigene Programme einbaust), dann sende bitte eine kleine
  20.     * Entschädigung (mindestens eine Postkarte) an die folgende Adresse:
  21.     *
  22.     *       Fin Schuppenhauer
  23.     *       Braußpark 10
  24.     *       2000 Hamburg 26
  25.     *
  26.     * Für Kritik, Fehlerberichte und Verbesserungsvorschläge danke ich
  27.     * im vorraus.
  28.     *
  29.     * Zu diesem Programm gehören folgende Dateien:
  30.     *
  31.     *    ° MenuGadget.def     (diese Datei)
  32.     *    ° MenuGadget.mod
  33.     *    ° MenuGadget.sym
  34.     *    ° MenuGadget.obj
  35.     *    ° MenuGadget.readme
  36.     *    ° MenuGadgetDemo.mod
  37.     *    ° MenuGadgetDemo
  38.     *
  39.     * Diese Dateien liegen entweder in dieser Form oder gepackt als
  40.     * MenuGadget.lzh-File vor.
  41.     *
  42.     * SIE DÜRFEN NICHT VERÄNDERT WERDEN (wenn nicht anderes erklärt wird)
  43.     * UND NUR KOMPLETT ÜBER ELEKTRONISCHEN WEGE ODER AUF PUBLIC DOMAIN
  44.     * DISK WEITERGEGEBEN WERDEN. IN BEIDEN FÄLLEN DARF DIE UNKOSTENPAU-
  45.     * SCHALE NICHT DM 5.- ÜBERSCHREITEN.
  46.     * FÜR DIE FUNKTIONSFÄHIGKEIT DER PROGRAMME SOWIE MÖGLICHE SCHÄDEN
  47.     * BEI DEREN BENUTZUNG WIRD KEINE GARANTIE ÜBERNOMMEN.
  48.     *
  49.     * Soft- und Hardware-Voraussetzungen:
  50.     *
  51.     *    ° Amiga xxxx mit mindst. OS2.04
  52.     *    ° Modula-2 Compiler M2Amiga mindst. V4.0
  53.     *
  54.     * Bekannte Fehler:
  55.     *    - keine
  56.     *)
  57.  
  58. IMPORT   id:IntuitionD, il:IntuitionL,
  59.          gd:GadToolsD,  gl:GadToolsL,
  60.          ed:ExecD,      el:ExecL,
  61.          ud:UtilityD;
  62. FROM IntuitionD   IMPORT WaTags, IDCMPFlags;
  63. FROM GadToolsD    IMPORT GtTags;
  64. FROM SYSTEM       IMPORT ADR,ADDRESS,TAG;
  65. FROM MenuGadget   IMPORT SetMenuGadget, HandleMenuGadget, MENUGADGET_KIND,
  66.                          StrPtr;
  67.  
  68. CONST (* Definition der Gadget-IDs *)
  69.       MG_SYSTEM = 1;
  70.       MG_OS     = 2;
  71.       TG_SYSTEM = 3;
  72.       SG_OS     = 4;
  73.  
  74. TYPE  GadgetTypes = (mgSystem, mgOS, tgSystem, sgOS);
  75.       SystemListT = ARRAY [0..9] OF StrPtr;
  76.       OSListT     = ARRAY [0..8] OF StrPtr;
  77.  
  78. VAR   pubScreen   : id.ScreenPtr;
  79.       window      : id.WindowPtr;
  80.       gadgets     : ARRAY GadgetTypes OF id.GadgetPtr;
  81.       newgadgets  : ARRAY GadgetTypes OF gd.NewGadget;
  82.       tagBuffer   : ARRAY [0..49] OF LONGINT;
  83.       glist       :=id.GadgetPtr{NIL};
  84.       gad         : id.GadgetPtr;
  85.       vi          : ADDRESS;
  86.       SystemList  :=SystemListT{
  87.                      ADR("Amiga 500"),
  88.                      ADR("Amiga 500+"),
  89.                      ADR("Amiga 600"),
  90.                      ADR("Amiga 1000"),
  91.                      ADR("Amiga 1200"),
  92.                      ADR("Amiga 2000"),
  93.                      ADR("Amiga 2500"),
  94.                      ADR("Amiga 3000"),
  95.                      ADR("Amiga 4000"),
  96.                      NIL};
  97.       OSList      :=OSListT{
  98.                      ADR("OS 1.2"),
  99.                      ADR("OS 1.3"),
  100.                      ADR("OS 2.04"),
  101.                      ADR("OS 2.1"),
  102.                      ADR("OS 3.0"),
  103.                      ADR("Unix"),
  104.                      ADR("MS-DOS"),
  105.                      ADR("other"),
  106.                      NIL};
  107.       dummy       : ADDRESS;     (* Weil: Ausdruck zu komplex. Zu wenig...*)
  108.  
  109.    PROCEDURE HandleIDCMP;
  110.    VAR   item     : LONGINT;
  111.          ende     : BOOLEAN;
  112.          msg      : id.IntuiMessagePtr;
  113.          msgGad   : id.GadgetPtr;
  114.    BEGIN
  115.       ende := FALSE;
  116.       WHILE NOT(ende) DO
  117.          el.WaitPort (window^.userPort);
  118.  
  119.          msg := gl.GTGetIMsg(window^.userPort);
  120.          WHILE msg#NIL DO
  121.             IF closeWindow IN msg^.class THEN
  122.                ende := TRUE;
  123.             ELSIF gadgetUp IN msg^.class THEN
  124.                msgGad := msg^.iAddress;
  125.                CASE msgGad^.gadgetID OF
  126.                   MG_SYSTEM :
  127.                      item := HandleMenuGadget (gadgets[mgSystem], window);
  128.                      IF item >= 0 THEN
  129.                         dummy := SystemList[item];
  130.                         gl.GTSetGadgetAttrsA (gadgets[tgSystem], window,
  131.                            NIL, TAG(tagBuffer,
  132.                            gttxText,      dummy,
  133.                            ud.tagEnd));
  134.                      END;
  135.                 | MG_OS :
  136.                      item := HandleMenuGadget (gadgets[mgOS], window);
  137.                      IF item >= 0 THEN
  138.                         dummy := OSList[item];
  139.                         gl.GTSetGadgetAttrsA (gadgets[sgOS], window,
  140.                            NIL, TAG(tagBuffer,
  141.                            gtstString,    dummy,
  142.                            ud.tagEnd));
  143.                      END;
  144.                 | SG_OS :
  145.                   ELSE
  146.                END;
  147.             END;
  148.             gl.GTReplyIMsg (msg);
  149.             msg := gl.GTGetIMsg(window^.userPort);
  150.          END;
  151.       END;
  152.    END HandleIDCMP;
  153.  
  154. BEGIN
  155.    (* Unser Fenster soll auf dem Default-Public-Screen erscheinen; wir
  156.     * besorgen uns einen Lock auf diesen, um der Applikation, die den
  157.     * Screen erzeugt hat mitzuteilen, daß wir ein Fenster hierauf ge-
  158.     * öffnet haben (bzw. noch werden).
  159.     *)
  160.    pubScreen := il.LockPubScreen(NIL);
  161.    IF pubScreen # NIL THEN
  162.       (* Für die Benutzung der Routinen der gadTool.libraray benötigen
  163.        * wir einen Zeiger auf die VisualInfo-rmationen des Screens:
  164.        *)
  165.       vi := gl.GetVisualInfoA(pubScreen,TAG(tagBuffer,ud.tagEnd));
  166.       IF vi # NIL THEN
  167.          (* Außerdem brauchen wir für die Gadgets noch zusätzlichen
  168.           * Platz, in dem das Betriebssystem Daten zum Handling mit den
  169.           * GadTools-Gadget ablegen kann:
  170.           *)
  171.          gad := gl.CreateContext(glist);
  172.          IF gad # NIL THEN
  173.             (* Ok. Jetzt können wir unseres Gadgets definieren und das
  174.              * Fenster öffnen:
  175.              *)
  176.             WITH newgadgets[tgSystem] DO
  177.                leftEdge    := 20;
  178.                topEdge     := 20;
  179.                width       := 300;
  180.                height      := 12;
  181.                gadgetText  := ADR("System");
  182.                textAttr    := pubScreen^.font;
  183.                gadgetID    := TG_SYSTEM;
  184.                flags       := gd.NewGadgetFlagSet{gd.placetextAbove};
  185.                visualInfo  := vi;
  186.                userData    := NIL;
  187.             END;
  188.             WITH newgadgets[sgOS] DO
  189.                leftEdge    := 20;
  190.                topEdge     := 50;
  191.                width       := 300;
  192.                height      := 12;
  193.                gadgetText  := ADR("Operating System");
  194.                textAttr    := pubScreen^.font;
  195.                gadgetID    := SG_OS;
  196.                flags       := gd.NewGadgetFlagSet{gd.placetextAbove};
  197.                visualInfo  := vi;
  198.                userData    := NIL;
  199.             END;
  200.             WITH newgadgets[mgSystem] DO
  201.                width       := 13;
  202.                height      := 12;
  203.                leftEdge    := 320;
  204.                topEdge     := 20;
  205.                gadgetText  := NIL;
  206.                textAttr    := pubScreen^.font;
  207.                gadgetID    := MG_SYSTEM;
  208.                flags       := gd.NewGadgetFlagSet{};
  209.                visualInfo  := vi;
  210.                userData    := ADR(SystemList);
  211.             END;
  212.             WITH newgadgets[mgOS] DO
  213.                width       := 13;
  214.                height      := 12;
  215.                leftEdge    := 320;
  216.                topEdge     := 50;
  217.                gadgetText  := NIL;
  218.                textAttr    := pubScreen^.font;
  219.                gadgetID    := MG_OS;
  220.                flags       := gd.NewGadgetFlagSet{};
  221.                visualInfo  := vi;
  222.                userData    := ADR(OSList);
  223.             END;
  224.             gadgets[tgSystem] := gl.CreateGadgetA(gd.textKind, gad^,
  225.                   newgadgets[tgSystem], TAG(tagBuffer,
  226.                   gttxText,   ADR("Select your system -->"),
  227.                   gttxBorder, TRUE,
  228.                   ud.tagEnd));
  229.             IF gadgets[tgSystem]#NIL THEN
  230.                gadgets[sgOS] := gl.CreateGadgetA(gd.stringKind,
  231.                      gadgets[tgSystem]^, newgadgets[sgOS], TAG(tagBuffer,
  232.                      gtstString, ADR("Type in your OS or select one -->"),
  233.                      gtstMaxChars, 60,
  234.                      ud.tagEnd));
  235.                IF gadgets[sgOS]#NIL THEN
  236.                   gadgets[mgSystem] := SetMenuGadget(MENUGADGET_KIND,
  237.                         gadgets[sgOS]^, newgadgets[mgSystem], TAG(tagBuffer,
  238.                         ud.tagEnd));
  239.                   gadgets[mgOS] := SetMenuGadget(MENUGADGET_KIND,
  240.                         gadgets[mgSystem]^, newgadgets[mgOS], TAG(tagBuffer,
  241.                         ud.tagEnd));
  242.  
  243.                   window := il.OpenWindowTagList(NIL,TAG(tagBuffer,
  244.                         waTitle,       ADR("MenuGadgetDemo"),
  245.                         waWidth,       400,
  246.                         waHeight,      80,
  247.                         waLeft,        0,
  248.                         waTop,         170,
  249.                         waGadgets,     glist,
  250.                         waCloseGadget, TRUE,
  251.                         waDragBar,     TRUE,
  252.                         waActivate,    TRUE,
  253.                         waGimmeZeroZero,TRUE,
  254.                         waPubScreen,   pubScreen,
  255.                         waIDCMP,       id.IDCMPFlagSet{closeWindow}+gd.buttonIDCMP,
  256.                         ud.tagEnd));
  257.                   IF window # NIL THEN
  258.                      (* Ok. Alles konnte erfolgreich initialisiert werden.
  259.                       * Jetzt können wir unser Programm starten:
  260.                       *)
  261.                       gl.GTRefreshWindow (window, NIL);
  262.  
  263.                       HandleIDCMP;
  264.  
  265.                   END;
  266.                   il.CloseWindow(window);
  267.                END;
  268.             END;
  269.          END;
  270.          gl.FreeGadgets(glist);
  271.          gl.FreeVisualInfo(vi);
  272.       END;
  273.       il.UnlockPubScreen(NIL,pubScreen);
  274.    END;
  275. END MenuGadgetDemo.
  276.